package bsc.war.delegate;

import bsc.ejb.entity.ActionPlan;
import bsc.ejb.entity.ActionPlanPerson;
import bsc.ejb.entity.Area;
import bsc.ejb.entity.Attachment;
import bsc.ejb.entity.ColorimetrySettings;
import bsc.ejb.entity.Comparator;
import bsc.ejb.entity.ComparatorDimensionalCut;
import bsc.ejb.entity.Dimension;
import bsc.ejb.entity.DimensionMember;
import bsc.ejb.entity.DimensionalCut;
import bsc.ejb.entity.DimensionalCutMember;
import bsc.ejb.entity.ScoreDomain;
import bsc.ejb.entity.Employee;
import bsc.ejb.entity.Label;
import bsc.ejb.entity.Map;
import bsc.ejb.entity.MapDrawingSettings;
import bsc.ejb.entity.Milestone;
import bsc.ejb.entity.MilestoneTracer;
import bsc.ejb.entity.Note;
import bsc.ejb.entity.Objective;
import bsc.ejb.entity.Person;
import bsc.ejb.entity.PersonScoreCard;
import bsc.ejb.entity.PersonScoreDomain;
import bsc.ejb.entity.Perspective;
import bsc.ejb.entity.Pointer;
import bsc.ejb.entity.Project;
import bsc.ejb.entity.SRM;
import bsc.ejb.entity.SRMTopic;
import bsc.ejb.entity.ScoreCard;
import bsc.ejb.entity.ScoreCardDimension;
import bsc.ejb.entity.ScoreCardDomain;
import bsc.ejb.entity.ScoreCardRelation;
import bsc.ejb.entity.ScoreView;
import bsc.ejb.entity.Settings;
import bsc.ejb.entity.Task;
import bsc.ejb.entity.Theme;
import bsc.ejb.entity.Topic;
import bsc.ejb.entity.TopicScoreView;
import bsc.ejb.entity.Tracer;
import bsc.ejb.facade.BSCFacadeLocal;
import bsc.ejb.metadata.Activity;
import bsc.ejb.metadata.Alert;
import bsc.ejb.metadata.Colorimetry;
import bsc.ejb.metadata.Comparation;
import bsc.ejb.metadata.Formula;
import bsc.ejb.metadata.Framework;
import bsc.ejb.metadata.Graph;
import bsc.ejb.metadata.Icon;
import bsc.ejb.metadata.Lang;
import bsc.ejb.metadata.License;
import bsc.ejb.metadata.MapDrawing;
import bsc.ejb.metadata.NoteType;
import bsc.ejb.metadata.Profile;
import bsc.ejb.metadata.SMTP;
import bsc.ejb.metadata.TimePeriod;
import bsc.ejb.metadata.Unit;
import bsc.war.service.ServiceLocator;
import java.util.Date;
import java.util.List;
import javax.ejb.EJBException;
import javax.naming.NamingException;
import javax.persistence.NoResultException;
import org.apache.log4j.Logger;

/**
 *
 * @author memozac
 */
public class DelegateBSC {

    private static Logger logger = Logger.getLogger(DelegateBSC.class);
    private BSCFacadeLocal efl;

    public DelegateBSC() throws Exception {
        try {
            efl = (BSCFacadeLocal) (ServiceLocator.getInstance().lookup("BSC/BSCFacade/local"));
        } catch (NamingException ne) {
            logger.fatal("Cannot obtain BSCFacadeLocal!", ne);
        }
    }

    /**
     * <ENTITY>
     */
    public ActionPlan findActionPlan(Long idActionPlan) {
        try {
            return efl.findActionPlan(idActionPlan);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findActionPlan(" + idActionPlan + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    //ActionPlan
    public List<ActionPlan> findActionPlan(ScoreCard scoreCard) {
        return efl.findActionPlan(scoreCard);
    }

    // Update
    public void updateActionPlan(ActionPlan actionPlan) {
        efl.updateActionPlan(actionPlan);
    }

    //ActionPlanPerson
    public ActionPlanPerson findActionPlanPerson(ActionPlan actionPlan, ActionPlanPerson.Profile actionPlanPersonProfile) {
        return efl.findActionPlanPerson(actionPlan, actionPlanPersonProfile);
    }

    // Find
    public List<ActionPlanPerson> findActionPlanPerson() {
        return efl.findActionPlanPerson();
    }

    public ActionPlanPerson findActionPlanPerson(Long idActionPlanPerson) {
        try {
            return efl.findActionPlanPerson(idActionPlanPerson);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findActionPlanPerson(" + idActionPlanPerson + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    // Create
    public void createActionPlanPerson(ActionPlanPerson actionPlanPerson) {
        efl.createActionPlanPerson(actionPlanPerson);
    }

    // Update
    public void updateActionPlanPerson(ActionPlanPerson actionPlanPerson) {
        efl.updateActionPlanPerson(actionPlanPerson);
    }

    // Delete
    public void deleteActionPlanPerson(ActionPlanPerson actionPlanPerson) {
        efl.deleteActionPlanPerson(actionPlanPerson);
    }

    // Area
    public Area findArea(Long idArea) {
        return efl.findArea(idArea);
    }

    // Attachment
    public Attachment findAttachment(Long idAttachment) {
        try {
            return efl.findAttachment(idAttachment);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findAttachment(" + idAttachment + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;

    }

    public List<Attachment> findAttachment(Note note) {
        return efl.findAttachment(note);
    }

    public List<Attachment> findAttachment(ActionPlan actionPlan) {
        return efl.findAttachment(actionPlan);
    }
    // Comparator

    public Comparator findComparator(Long idComparator) {
        try {
            return efl.findComparator(idComparator);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findComparator(" + idComparator + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Comparator> findComparator(Pointer pointer) {
        return efl.findComparator(pointer);
    }

    public Comparator findComparator(Pointer pointer, Comparation comparation) {
        return efl.findComparator(pointer, comparation);
    }

    public List<Comparator> findComparator(DimensionalCut dimensionalCut) {
        return efl.findComparator(dimensionalCut);
    }

    //ComparatorDimensionalCut
    public ComparatorDimensionalCut findComparatorDimensionalCut(Comparator comparator, DimensionalCut dimensionalCut, Date date) {


        try {
            return efl.findComparatorDimensionalCut(comparator, dimensionalCut, date);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query");
            }
        }
        return null;
    }

    public List<ComparatorDimensionalCut> findComparatorDimensionalCut(DimensionalCut dimensionalCut) {
        return efl.findComparatorDimensionalCut(dimensionalCut);
    }

    public List<ComparatorDimensionalCut> findComparatorDimensionalCut(DimensionalCut dimensionalCut, Date date) {
        return efl.findComparatorDimensionalCutDate(dimensionalCut, date);
    }

    public List<Date> findComparatorDimensionalCutDate(DimensionalCut dimensionalCut) {
        return efl.findComparatorDimensionalCutDate(dimensionalCut);
    }

    public Double findComparatorDimensionalCut(Comparator comparator, Date firstDate, Date lastDate) {
        return efl.findComparatorDimensionalCut(comparator, firstDate, lastDate);
    }

    public Double findComparatorDimensionalCut(Comparator comparator, Date firstDate, Date lastDate, DimensionalCut dimensionalCut) {
        return efl.findComparatorDimensionalCut(comparator, firstDate, lastDate, dimensionalCut);
    }

    // Dimension
    public List<Dimension> findDimension() {
        return efl.findDimension();
    }

    public Dimension findDimension(Long idDimension) {
        try {
            return efl.findDimension(idDimension);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findDimension(" + idDimension + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Dimension> findDimension(ScoreCard scoreCard) {
        return efl.findDimension(scoreCard);
    }
    // DimensionMember

    public List<DimensionMember> findDimensionMember(Boolean withBusyMembers) {
        return efl.findDimensionMember(withBusyMembers);
    }

    public DimensionMember findDimensionMember(Long idDimensionMember) {
        try {
            return efl.findDimensionMember(idDimensionMember);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findDimensionMember(" + idDimensionMember + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<DimensionMember> findDimensionMember(Dimension dimension) {
        return efl.findDimensionMember(dimension);
    }

    public List<DimensionMember> findDimensionMember(DimensionalCut dimensionalCut) {
        return efl.findDimensionMember(dimensionalCut);
    }

    public List<DimensionMember> findDimensionMember(DimensionMember dimensionMember) {
        return efl.findDimensionMember(dimensionMember);
    }

    public List<DimensionMember> findRootDimensionMember(DimensionalCut dimensionalCut) {
        return efl.findRootDimensionMember(dimensionalCut);
    }
    // DimensionalCut

    public DimensionalCut findDimensionalCut(Long idDimensionalCut) {
        try {
            return efl.findDimensionalCut(idDimensionalCut);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findDimensionalCut(" + idDimensionalCut + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<DimensionalCut> findDimensionalCut(DimensionMember dimension) {
        return efl.findDimensionalCut(dimension);
    }

    public List<DimensionalCut> findDimensionalCut(Comparator comparator) {
        return efl.findDimensionalCut(comparator);
    }

    public List<DimensionalCut> findDimensionalCut(Pointer pointer) {
        return efl.findDimensionalCut(pointer);
    }
    // DimensionalCut

    public List<DimensionalCutMember> findDimensionalCutMember(DimensionalCut dimensionalcut) {
        return efl.findDimensionalCutMember(dimensionalcut);
    }
    // ScoreCardDimension

    public ScoreCardDimension findScoreCardDimension(Long idScoreCardDimension) {
        try {
            return efl.findScoreCardDimension(idScoreCardDimension);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreCardDimension(" + idScoreCardDimension + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<ScoreCardDimension> findScoreCardDimension(ScoreCard scoreCard) {
        return efl.findScoreCardDimension(scoreCard);
    }
    // ScoreDomain

    public List<ScoreDomain> findScoreDomain() {
        return efl.findScoreDomain();
    }

    public List<ScoreDomain> findScoreDomainSpecial(Long idScoreDomain) {
        return efl.findScoreDomainSpecial(idScoreDomain);
    }

    public ScoreDomain findScoreDomain(Long idDomain) {
        try {
            return efl.findScoreDomain(idDomain);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findDomain(" + idDomain + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<ScoreDomain> findScoreDomain(Person person) {
        return efl.findScoreDomain(person);
    }

    public List<ScoreDomain> findScoreDomain(Person person, Boolean defaultDomain) {
        return efl.findScoreDomain(person, defaultDomain);
    }

    public ScoreCardDomain findScoreCardDomain(Long idScoreCardDomain) {
        try {
            return efl.findScoreCardDomain(idScoreCardDomain);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreCardDomain(" + idScoreCardDomain + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public ScoreCardRelation findScoreCardRelation(Long idScoreCardRelation) {
        try {
            return efl.findScoreCardRelation(idScoreCardRelation);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreCardRelation(" + idScoreCardRelation + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public ScoreCardRelation findScoreCardRelation(Long idScoreCard, Long idOtherScoreCard) {
        try {
            return efl.findScoreCardRelation(idScoreCard, idOtherScoreCard);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreCardRelation(" + idScoreCard + "," + idOtherScoreCard + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Employee

    public Employee findEmployee(Long idEmployee) {
        try {
            return efl.findEmployee(idEmployee);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findEmployee(" + idEmployee + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Label

    public Label findLabel(Long idLabel) {
        try {
            return efl.findLabel(idLabel);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findLabel(" + idLabel + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Label> findLabel(Project project) {
        return efl.findLabel(project);
    }
    // Map

    public Map findMap(Long idMap) {
        try {
            return efl.findMap(idMap);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMap(" + idMap + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Map> findMap() {
        return efl.findMap();
    }
    // MapDrawingSettings

    public MapDrawingSettings findMapDrawingSettings(Long idMapDrawingSettings) {
        try {
            return efl.findMapDrawingSettings(idMapDrawingSettings);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMap(" + idMapDrawingSettings + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public MapDrawingSettings findMapDrawingSettings(Settings settings, MapDrawing mapDrawing) {
        try {
            return efl.findMapDrawingSettings(settings, mapDrawing);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMap(" + settings + "," + mapDrawing + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<MapDrawingSettings> findMapDrawingSettings(MapDrawing mapDrawing) {
        return efl.findMapDrawingSettings(mapDrawing);
    }

    public List<MapDrawingSettings> findMapDrawingSettings(Settings settings) {
        return efl.findMapDrawingSettings(settings);
    }
    // Milestone

    public Milestone findMilestone(Long idMilestone) {
        try {
            return efl.findMilestone(idMilestone);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMilestone(" + idMilestone + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Milestone> findMilestone(Project project) {
        return efl.findMilestone(project);
    }

    public List<Milestone> findMilestone(Tracer tracer) {
        return efl.findMilestone(tracer);
    }
    // MilestoneTracer

    public MilestoneTracer findMilestoneTracer(Long idMilestoneTracer) {
        try {
            return efl.findMilestoneTracer(idMilestoneTracer);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMilestoneTracer(" + idMilestoneTracer + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public MilestoneTracer findMilestoneTracer(Milestone milestone, Tracer tracer) {
        try {
            return efl.findMilestoneTracer(milestone, tracer);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query");
            }
        }
        return null;
    }

    public List<MilestoneTracer> findMilestoneTracer(Milestone milestone) {
        return efl.findMilestoneTracer(milestone);
    }
    // Note

    public Note findNote(Long idNote) {
        try {
            return efl.findNote(idNote);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findNote(" + idNote + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Note> findNote(ScoreCard scoreCard) {
        return efl.findNote(scoreCard);
    }

    public List<Note> findNote(Person person) {
        return efl.findNote(person);
    }
    // Objective

    public Objective findObjective(Long idObjective) {
        try {
            return efl.findObjective(idObjective);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findObjective(" + idObjective + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Person

    public List<Person> findAvaliablePerson() {
        return efl.findAvaliablePerson();
    }

    public List<Person> findPerson() {
        return efl.findPerson();
    }

    public Person findPerson(Long idPerson) {
        try {
            return efl.findPerson(idPerson);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPerson(" + idPerson + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Person> findPerson(ScoreDomain scoreDomain) {
        return efl.findPerson(scoreDomain);
    }

    public Person findPerson(String username, String password) {
        try {
            return efl.findPerson(username, password);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPerson(" + username + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // PersonScoreDomain

    public List<PersonScoreDomain> findPersonScoreDomain(Person person) {
        return efl.findPersonScoreDomain(person);
    }

    public List<PersonScoreDomain> findPersonScoreDomain(ScoreDomain scoreDomain) {
        return efl.findPersonScoreDomain(scoreDomain);
    }

    public PersonScoreDomain findPersonScoreDomain(Person person, ScoreDomain scoreDomain) {
        try {
            return efl.findPersonScoreDomain(person, scoreDomain);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPerson(" + person + "," + scoreDomain + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // PersonScoreCard

    public List<Person> findPerson(ScoreCard scoreCard) {
        return efl.findPerson(scoreCard);
    }

    public PersonScoreCard findPersonScoreCard(Long idPersonScoreCard) {
        try {
            return efl.findPersonScoreCard(idPersonScoreCard);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPersonScoreCard(" + idPersonScoreCard + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public PersonScoreCard findPersonScoreCard(Person person, ScoreCard scoreCard) {
        try {
            return efl.findPersonScoreCard(person, scoreCard);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPersonScoreCard(" + person + "," + scoreCard + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<PersonScoreCard> findPersonScoreCard(Person person) {
        return efl.findPersonScoreCard(person);
    }

    public List<PersonScoreCard> findPersonScoreCard(ScoreCard scoreCard) {
        return efl.findPersonScoreCard(scoreCard);
    }

    // Perspective
    public Perspective findPerspective(Long idPerspective) {
        try {
            return efl.findPerspective(idPerspective);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPerspective(" + idPerspective + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Pointer

    public Pointer findPointer(Long idPointer) {
        try {
            return efl.findPointer(idPointer);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findPointer(" + idPointer + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Project

    public List<Project> findProject() {
        return efl.findProject();
    }

    public Project findProject(Long idProject) {
        try {
            return efl.findProject(idProject);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findProject(" + idProject + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Project> findProject(Person person) {
        return efl.findProject(person);
    }

    // SRM
    public List<SRM> findSRM() {
        return efl.findSRM();
    }

    public SRM findSRM(Long idSRM) {
        try {
            return efl.findSRM(idSRM);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSRM(" + idSRM + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<SRM> findSRM(ScoreView scoreView) {
        return efl.findSRM(scoreView);
    }
    // SRMTopic

    public SRMTopic findSRMTopic(Long idSRMTopic) {
        try {
            return efl.findSRMTopic(idSRMTopic);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSRM(" + idSRMTopic + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<SRMTopic> findSRMTopic(SRM SRM) {
        return efl.findSRMTopic(SRM);
    }

    public List<SRMTopic> findSRMTopic(Topic topic) {
        return efl.findSRMTopic(topic);
    }

    public SRMTopic findSRMTopic(SRM SRM, Topic topic) {
        try {
            return efl.findSRMTopic(SRM, topic);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSRM(" + SRM + "," + topic + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // ScoreCard

    public List<ScoreCard> findScoreCard() {
        return efl.findScoreCard();
    }

    public ScoreCard findScoreCard(Long idScoreCard) {
        try {
            return efl.findScoreCard(idScoreCard);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreCard(" + idScoreCard + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<ScoreCard> findScoreCard(ScoreDomain scoreDomain) {
        return efl.findScoreCard(scoreDomain);
    }

    public List<ScoreCard> findScoreCard(ScoreCard scoreCard) {
        return efl.findScoreCard(scoreCard);
    }

    public List<ScoreCard> findOtherScoreCards(Long idScoreCard) {
        return efl.findOtherScoreCards(idScoreCard);
    }

    public List<ScoreCard> findOtherScoreCardsRevert(Long idScoreCard) {
        return efl.findOtherScoreCardsRevert(idScoreCard);
    }

    // ScoreView
    public List<ScoreView> findScoreView() {
        return efl.findScoreView();
    }

    public ScoreView findScoreView(Long idScoreView) {
        try {
            return efl.findScoreView(idScoreView);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findScoreView(" + idScoreView + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<ScoreView> findScoreView(Topic topic) {
        return efl.findScoreView(topic);
    }
    // Settings

    public Settings findSettings(Long idSettings) {
        try {
            return efl.findSettings(idSettings);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSettings(" + idSettings + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Task

    public Task findTask(Long idTask) {
        try {
            return efl.findTask(idTask);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTask(" + idTask + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Task> findTask(Project project) {
        return efl.findTask(project);
    }

    public List<Task> findTask(Task task) {
        return efl.findTask(task);
    }

    public Task findRootTask(Project project) {
        try {
            return efl.findRootTask(project);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findRootTask(" + project + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Theme

    public Theme findTheme(Long idTheme) {
        try {
            return efl.findTheme(idTheme);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTheme(" + idTheme + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Topic

    public Topic findTopic(Long idTopic) {
        try {
            return efl.findTopic(idTopic);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTopic(" + idTopic + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Topic> findTopic(ScoreView scoreView) {
        return efl.findTopic(scoreView);
    }

    public List<Topic> findTopic(SRM SRM) {
        return efl.findTopic(SRM);
    }

    public List<Topic> findTopic(ScoreCard scoreCard) {
        return efl.findTopic(scoreCard);
    }

    public List<Topic> findTopicsView(ScoreView scoreView) {
        return efl.findTopicsView(scoreView);
    }
    // TopicScoreView

    public TopicScoreView findTopicScoreView(Topic topic, ScoreView scoreView) {
        try {
            return efl.findTopicScoreView(topic, scoreView);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTopicScoreView(" + topic + "," + scoreView + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<TopicScoreView> findTopicScoreView(Topic topic) {
        return efl.findTopicScoreView(topic);
    }

    public List<TopicScoreView> findTopicScoreView(ScoreView scoreView) {
        return efl.findTopicScoreView(scoreView);
    }

    // Tracer
    public Tracer findTracer(Long idTracer) {
        try {
            return efl.findTracer(idTracer);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTracer(" + idTracer + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Tracer> findTracer(Milestone milestone) {
        return efl.findTracer(milestone);
    }

    public List<Tracer> findTracer(Project project) {
        return efl.findTracer(project);
    }

    public Tracer findTracer(Project project, Tracer.Type type) {
        try {
            return efl.findTracer(project, type);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTracer(" + project + "," + type + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    // create
    public void createArea(Area area) {
        efl.createArea(area);
    }

    public void createAttachment(Attachment attachment) {
        efl.createAttachment(attachment);
    }

    public void createColorimetrySettings(ColorimetrySettings colorimetrySettings) {
        efl.createColorimetrySettings(colorimetrySettings);
    }

    public void createComparator(Comparator comparator) {
        efl.createComparator(comparator);
    }

    public void createComparatorDimensionalCut(ComparatorDimensionalCut comparatorDimensionalCut) {
        efl.createComparatorDimensionalCut(comparatorDimensionalCut);
    }

    public void createDimension(Dimension dimension) {
        efl.createDimension(dimension);
    }

    public void createDimensionMember(DimensionMember dimensionMember) {
        efl.createDimensionMember(dimensionMember);
    }

    public void createDimensionalCut(DimensionalCut dimensionalCut) {
        efl.createDimensionalCut(dimensionalCut);
    }

    public void createDimensionalCutMember(DimensionalCutMember dimensionalCutMember) {
        try {
            efl.createDimensionalCutMember(dimensionalCutMember);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                System.out.println("no jalo");
            } else {
                logger.warn("No entity found in query, method: findActivity(" + "TEST" + ") [" + e.getClass().getSimpleName() + "]");
            }
        }

    }

    public void createEmployee(Employee employee) {
        efl.createEmployee(employee);
    }

    public void createLabel(Label label) {
        efl.createLabel(label);
    }

    public void createMap(Map map) {
        efl.createMap(map);
    }

    public void createMilestone(Milestone milestone) {
        efl.createMilestone(milestone);
    }

    public void createMilestoneTracer(MilestoneTracer milestoneTracer) {
        efl.createMilestoneTracer(milestoneTracer);
    }

    public void createNote(Note note) {
        efl.createNote(note);
    }

    public void createObjective(Objective objective) {
        efl.createObjective(objective);
    }

    public void createPerson(Person person) {
        efl.createPerson(person);
    }

    public void createPersonScoreCard(PersonScoreCard personScoreCard) {
        efl.createPersonScoreCard(personScoreCard);
    }

    public void createPersonScoreDomain(PersonScoreDomain personScoreDomain) {
        efl.createPersonScoreDomain(personScoreDomain);
    }

    public void createPerspective(Perspective perspective) {
        efl.createPerspective(perspective);
    }

    public void createPointer(Pointer pointer) {
        efl.createPointer(pointer);
    }

    public void createProject(Project project) {
        efl.createProject(project);
    }

    public void createSRM(SRM SRM) {
        efl.createSRM(SRM);
    }

    public void createSRMTopic(SRMTopic SRMTopic) {
        efl.createSRMTopic(SRMTopic);
    }

    public void createScoreCard(ScoreCard scoreCard) {
        efl.createScoreCard(scoreCard);
    }

    public void createScoreCardDimension(ScoreCardDimension scoreCardDimension) {
        efl.createScoreCardDimension(scoreCardDimension);
    }

    public void createScoreCardDomain(ScoreCardDomain scoreCardDomain) {
        efl.createScoreCardDomain(scoreCardDomain);
    }

    public void createScoreCardRelation(ScoreCardRelation scoreCardRelation) {
        efl.createScoreCardRelation(scoreCardRelation);
    }

    public void createScoreDomain(ScoreDomain scoreDomain) {
        efl.createScoreDomain(scoreDomain);
    }

    public void createScoreView(ScoreView scoreView) {
        efl.createScoreView(scoreView);
    }

    public void createSettings(Settings settings) {
        efl.createSettings(settings);
    }

    public void createTheme(Theme theme) {
        efl.createTheme(theme);
    }

    public void createTopic(Topic topic) {
        efl.createTopic(topic);
    }

    public void createTopicScoreView(TopicScoreView topicScoreView) {
        efl.createTopicScoreView(topicScoreView);
    }

    public void createTracer(Tracer tracer) {
        efl.createTracer(tracer);
    }

    // update
    public void updateArea(Area area) {
        efl.updateArea(area);
    }

    public void updateAttachment(Attachment attachment) {
        efl.updateAttachment(attachment);
    }

    public void updateColorimetrySettings(ColorimetrySettings colorimetrySettings) {
        efl.updateColorimetrySettings(colorimetrySettings);
    }

    public void updateComparator(Comparator comparator) {
        efl.updateComparator(comparator);
    }

    public void updateComparatorDimensionalCut(ComparatorDimensionalCut comparatorDimensionalCut) {
        efl.updateComparatorDimensionalCut(comparatorDimensionalCut);
    }

    public void updateDimension(Dimension dimension) {
        efl.updateDimension(dimension);
    }

    public void updateDimensionMember(DimensionMember dimensionMember) {
        efl.updateDimensionMember(dimensionMember);
    }

    public void updateDimensionalCut(DimensionalCut dimensionalCut) {
        efl.updateDimensionalCut(dimensionalCut);
    }

    public void updateDimensionalCutMember(DimensionalCutMember dimensionalCutMember) {
        efl.updateDimensionalCutMember(dimensionalCutMember);
    }

    public void updateDomain(ScoreDomain domain) {
        efl.updateDomain(domain);
    }

    public void updateEmployee(Employee employee) {
        efl.updateEmployee(employee);
    }

    public void updateLabel(Label label) {
        efl.updateLabel(label);
    }

    public void updateMap(Map map) {
        efl.updateMap(map);
    }

    public void updateMilestone(Milestone milestone) {
        efl.updateMilestone(milestone);
    }

    public void updateMilestoneTracer(MilestoneTracer milestoneTracer) {
        efl.updateMilestoneTracer(milestoneTracer);
    }

    public void updateNote(Note note) {
        efl.updateNote(note);
    }

    public void updateObjective(Objective objective) {
        efl.updateObjective(objective);
    }

    public void updatePerson(Person person) {
        efl.updatePerson(person);
    }

    public void updatePersonScoreCard(PersonScoreCard personScoreCard) {
        efl.updatePersonScoreCard(personScoreCard);
    }

    public void updatePersonScoreDomain(PersonScoreDomain personScoreDomain) {
        efl.updatePersonScoreDomain(personScoreDomain);
    }

    public void updatePerspective(Perspective perspective) {
        efl.updatePerspective(perspective);
    }

    public void updatePointer(Pointer pointer) {
        efl.updatePointer(pointer);
    }

    public void updateProject(Project project) {
        efl.updateProject(project);
    }

    public void updateSRM(SRM SRM) {
        efl.updateSRM(SRM);
    }

    public void updateSRMTopic(SRMTopic SRMTopic) {
        efl.updateSRMTopic(SRMTopic);
    }

    public void updateScoreCard(ScoreCard scoreCard) {
        efl.updateScoreCard(scoreCard);
    }

    public void updateScoreCardDimension(ScoreCardDimension scoreCardDimension) {
        efl.updateScoreCardDimension(scoreCardDimension);
    }

    public void updateScoreCardDomain(ScoreCardDomain scoreCardDomain) {
        efl.updateScoreCardDomain(scoreCardDomain);
    }

    public void updateScoreCardRelation(ScoreCardRelation scoreCardRelation) {
        efl.updateScoreCardRelation(scoreCardRelation);
    }

    public void updateScoreDomain(ScoreDomain scoreDomain) {
        efl.updateScoreDomain(scoreDomain);
    }

    public void updateScoreView(ScoreView scoreView) {
        efl.updateScoreView(scoreView);
    }

    public void updateSettings(Settings settings) {
        efl.updateSettings(settings);
    }

    public void updateTheme(Theme theme) {
        efl.updateTheme(theme);
    }

    public void updateTopic(Topic topic) {
        efl.updateTopic(topic);
    }

    public void updateTopicScoreView(TopicScoreView topicScoreView) {
        efl.updateTopicScoreView(topicScoreView);
    }

    public void updateTracer(Tracer tracer) {
        efl.updateTracer(tracer);
    }

    // delete
    public void deleteActionPlan(ActionPlan actionPlan) {
        efl.deleteActionPlan(actionPlan);
    }

    public void deleteArea(Area area) {
        efl.deleteArea(area);
    }

    public void deleteAttachment(Attachment attachment) {
        efl.deleteAttachment(attachment);
    }

    public void deleteComparator(Comparator comparator) {
        efl.deleteComparator(comparator);
    }

    public void deleteComparatorDimensionalCut(ComparatorDimensionalCut comparatorDimensionalCut) {
        efl.deleteComparatorDimensionalCut(comparatorDimensionalCut);
    }

    public void deleteDimension(Dimension dimension) {
        efl.deleteDimension(dimension);
    }

    public void deleteDimensionMember(DimensionMember dimensionMember) {
        efl.deleteDimensionMember(dimensionMember);
    }

    public void deleteDimensionalCut(DimensionalCut dimensionalCut) {
        efl.deleteDimensionalCut(dimensionalCut);
    }

    public void deleteDimensionalCutMember(DimensionalCutMember dimensionalCutMember) {
        efl.deleteDimensionalCutMember(dimensionalCutMember);
    }

    public void deleteDomain(ScoreDomain domain) {
        efl.deleteDomain(domain);
    }

    public void deleteEmployee(Employee employee) {
        efl.deleteEmployee(employee);
    }

    public void deleteLabel(Label label) {
        efl.deleteLabel(label);
    }

    public void deleteMap(Map map) {
        efl.deleteMap(map);
    }

    public void deleteMilestone(Milestone milestone) {
        efl.deleteMilestone(milestone);
    }

    public void deleteMilestoneTracer(MilestoneTracer milestoneTracer) {
        efl.deleteMilestoneTracer(milestoneTracer);
    }

    public void deleteNote(Note note) {
        efl.deleteNote(note);
    }

    public void deleteObjective(Objective objective) {
        efl.deleteObjective(objective);
    }

    public void deletePerson(Person person) {
        efl.deletePerson(person);
    }

    public void deletePersonScoreCard(PersonScoreCard personScoreCard) {
        efl.deletePersonScoreCard(personScoreCard);
    }

    public void deletePersonScoreDomain(PersonScoreDomain personScoreDomain) {
        efl.deletePersonScoreDomain(personScoreDomain);
    }

    public void deletePerspective(Perspective perspective) {
        efl.deletePerspective(perspective);
    }

    public void deletePointer(Pointer pointer) {
        efl.deletePointer(pointer);
    }

    public void deleteProject(Project project) {
        efl.deleteProject(project);
    }

    public void deleteSRM(SRM SRM) {
        efl.deleteSRM(SRM);
    }

    public void deleteSRMTopic(SRMTopic SRMTopic) {
        efl.deleteSRMTopic(SRMTopic);
    }

    public void deleteScoreCard(ScoreCard scoreCard) {
        efl.deleteScoreCard(scoreCard);
    }

    public void deleteScoreCardDimension(ScoreCardDimension scoreCardDimension) {
        efl.deleteScoreCardDimension(scoreCardDimension);
    }

    public void deleteScoreCardDomain(ScoreCardDomain scoreCardDomain) {
        efl.deleteScoreCardDomain(scoreCardDomain);
    }

    public void deleteScoreCardRelation(ScoreCardRelation scoreCardRelation) {
        efl.deleteScoreCardRelation(scoreCardRelation);
    }

    public void deleteScoreDomain(ScoreDomain scoreDomain) {
        efl.deleteScoreDomain(scoreDomain);
    }

    public void deleteScoreView(ScoreView scoreView) {
        efl.deleteScoreView(scoreView);
    }

    public void deleteSettings(Settings settings) {
        efl.deleteSettings(settings);
    }

    public void deleteTheme(Theme theme) {
        efl.deleteTheme(theme);
    }

    public void deleteTopic(Topic topic) {
        efl.deleteTopic(topic);
    }

    public void deleteTopicScoreView(TopicScoreView topicScoreView) {
        efl.deleteTopicScoreView(topicScoreView);
    }

    public void deleteTracer(Tracer tracer) {
        efl.deleteTracer(tracer);
    }

    /**
     * <METADATA>
     */
    // Activity
    public Activity findActivity(Long idActivity) {
        try {
            return efl.findActivity(idActivity);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findActivity(" + idActivity + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Alert

    public Alert findAlert(Long idAlert) {
        try {
            return efl.findAlert(idAlert);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findAlert(" + idAlert + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Colorimetry

    public ColorimetrySettings findColorimetrySettings(Colorimetry colorimetry, Settings settings) {
        try {
            return efl.findColorimetrySettings(colorimetry, settings);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findAlert(" + colorimetry + "," + settings + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<ColorimetrySettings> findColorimetrySettings(ScoreCard scoreCard) {
        return efl.findColorimetrySettings(scoreCard);
    }

    public List<ColorimetrySettings> findColorimetrySettings(Colorimetry colorimetry) {
        return efl.findColorimetrySettings(colorimetry);
    }

    public List<ColorimetrySettings> findColorimetrySettings(Settings settings) {
        return efl.findColorimetrySettings(settings);
    }

    public Colorimetry findColorimetry(Long idColorimetry) {
        try {
            return efl.findColorimetry(idColorimetry);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findColorimetry(" + idColorimetry + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Colorimetry> findColorimetry(Framework framework, Boolean frameworkMember) {
        return efl.findColorimetry(framework, frameworkMember);
    }

    public Colorimetry findColorimetry(ScoreCard scoreCard, Double score) {
        try {
            return efl.findColorimetry(scoreCard, score);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findColorimetry(" + scoreCard + "," + score + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Colorimetry> findColorimetry() {
        return efl.findColorimetry();
    }
    // Comparation

    public Comparation findComparation(Long idComparation) {
        try {
            return efl.findComparation(idComparation);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findComparation(" + idComparation + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public Comparation findComparation(Framework framework, Comparation.Type type) {
        try {
            return efl.findComparation(framework, type);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findComparation");
            }
        }
        return null;
    }

    public List<Comparation> findComparation(Framework framework, Boolean frameworkMember) {
        return efl.findComparation(framework, frameworkMember);
    }

    // Formula
    public Formula findFormula(Long idFormula) {
        try {
            return efl.findFormula(idFormula);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findFormula(" + idFormula + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Framework

    public Framework findFramework(Long idFramework) {
        try {
            return efl.findFramework(idFramework);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findFramework(" + idFramework + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public Framework findFramework(Boolean active) {
        return efl.findFramework(active);
    }

    public List<Framework> findFramework() {
        return efl.findFramework();
    }
    // Graph

    public Graph findGraph(Long idGraph) {
        try {
            return efl.findGraph(idGraph);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findGraph(" + idGraph + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Icon

    public Icon findIcon(Long idIcon) {
        try {
            return efl.findIcon(idIcon);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findIcon(" + idIcon + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Lang

    public Lang findLang(Long idLang) {
        try {
            return efl.findLang(idLang);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findLang(" + idLang + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Lang> findLang(Framework framework, Boolean frameworkMember) {
        return efl.findLang(framework, frameworkMember);
    }

    public List<Lang> findLang() {
        return efl.findLang();
    }
    // License

    public License findLicense(Long idLicense) {
        try {
            return efl.findLicense(idLicense);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findLicense(" + idLicense + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public License findCurrentLicense() {
        try {
            return efl.findCurrentLicense();
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            }
        }
        return null;
    }

    public List<License> findLicense() {
        return efl.findLicense();
    }
    // MapDrawing

    public MapDrawing findMapDrawing(Long idMapDrawing) {
        try {
            return efl.findMapDrawing(idMapDrawing);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findMapDrawing(" + idMapDrawing + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<MapDrawing> findMapDrawing(Framework framework, Boolean frameworkMember) {
        return efl.findMapDrawing(framework, frameworkMember);
    }

    public List<MapDrawing> findMapDrawing() {
        return efl.findMapDrawing();
    }
    // NoteType

    public NoteType findNoteType(Long idNoteType) {
        try {
            return efl.findNoteType(idNoteType);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findNoteType(" + idNoteType + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<NoteType> findNoteType(Framework framework, Boolean frameworkMember) {
        return efl.findNoteType(framework, frameworkMember);
    }

    public List<NoteType> findNoteType() {
        return efl.findNoteType();
    }
    // Profile

    public Profile findProfile(Long idProfile) {
        try {
            return efl.findProfile(idProfile);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findProfile(" + idProfile + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // SMTP

    public SMTP findSMTP(Long idSMTP) {
        try {
            return efl.findSMTP(idSMTP);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSMTP(" + idSMTP + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public SMTP findSMTP(Framework framework) {
        try {
            return efl.findSMTP(framework);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findSMTP(" + framework + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<SMTP> findSMTP(Framework framework, Boolean frameworkMember) {
        return efl.findSMTP(framework, frameworkMember);
    }

    // TimePeriod
    public TimePeriod findTimePeriod(Long idTimePeriod) {
        try {
            return efl.findTimePeriod(idTimePeriod);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findTimePeriod(" + idTimePeriod + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }
    // Unit

    public Unit findUnit(Long idUnit) {
        try {
            return efl.findUnit(idUnit);
        } catch (EJBException e) {
            if (e.getCausedByException() instanceof NoResultException) {
                return null;
            } else {
                logger.warn("No entity found in query, method: findUnit(" + idUnit + ") [" + e.getClass().getSimpleName() + "]");
            }
        }
        return null;
    }

    public List<Unit> findUnit(Framework framework, Boolean frameworkMember) {
        return efl.findUnit(framework, frameworkMember);
    }

    public List<Unit> findUnit() {
        return efl.findUnit();
    }

    // create
    public void createActionPlan(ActionPlan actionPlan) {
        efl.createActionPlan(actionPlan);
    }

    public void createActivity(Activity activity) {
        efl.createActivity(activity);
    }

    public void createAlert(Alert alert) {
        efl.createAlert(alert);
    }

    public void createColorimetry(Colorimetry colorimetry) {
        efl.createColorimetry(colorimetry);
    }

    public void createComparation(Comparation comparation) {
        efl.createComparation(comparation);
    }

    public void createFormula(Formula formula) {
        efl.createFormula(formula);
    }

    public void createFramework(Framework framework) {
        efl.createFramework(framework);
    }

    public void createGraph(Graph graph) {
        efl.createGraph(graph);
    }

    public void createIcon(Icon icon) {
        efl.createIcon(icon);
    }

    public void createLang(Lang lang) {
        efl.createLang(lang);
    }

    public void createLicense(License license) {
        efl.createLicense(license);
    }

    public void createMapDrawing(MapDrawing mapDrawing) {
        efl.createMapDrawing(mapDrawing);
    }

    public void createMapDrawingSettings(MapDrawingSettings mapDrawingSettings) {
        efl.createMapDrawingSettings(mapDrawingSettings);
    }

    public void createNoteType(NoteType noteType) {
        efl.createNoteType(noteType);
    }

    public void createProfile(Profile profile) {
        efl.createProfile(profile);
    }

    public void createSMTP(SMTP SMTP) {
        efl.createSMTP(SMTP);
    }

    public void createTimePeriod(TimePeriod timePeriod) {
        efl.createTimePeriod(timePeriod);
    }

    public void createUnit(Unit unit) {
        efl.createUnit(unit);
    }

    // update
    public void updateActivity(Activity activity) {
        efl.updateActivity(activity);
    }

    public void updateAlert(Alert alert) {
        efl.updateAlert(alert);
    }

    public void updateColorimetry(Colorimetry colorimetry) {
        efl.updateColorimetry(colorimetry);
    }

    public void updateComparation(Comparation comparation) {
        efl.updateComparation(comparation);
    }

    public void updateFormula(Formula formula) {
        efl.updateFormula(formula);
    }

    public void updateFramework(Framework framework) {
        efl.updateFramework(framework);
    }

    public void updateGraph(Graph graph) {
        efl.updateGraph(graph);
    }

    public void updateIcon(Icon icon) {
        efl.updateIcon(icon);
    }

    public void updateLang(Lang lang) {
        efl.updateLang(lang);
    }

    public void updateLicense(License license) {
        efl.updateLicense(license);
    }

    public void updateMapDrawing(MapDrawing mapDrawing) {
        efl.updateMapDrawing(mapDrawing);
    }

    public void updateMapDrawingSettings(MapDrawingSettings mapDrawingSettings) {
        efl.updateMapDrawingSettings(mapDrawingSettings);
    }

    public void updateNoteType(NoteType noteType) {
        efl.updateNoteType(noteType);
    }

    public void updateProfile(Profile profile) {
        efl.updateProfile(profile);
    }

    public void updateSMTP(SMTP SMTP) {
        efl.updateSMTP(SMTP);
    }

    public void updateTimePeriod(TimePeriod timePeriod) {
        efl.updateTimePeriod(timePeriod);
    }

    public void updateUnit(Unit unit) {
        efl.updateUnit(unit);
    }

    // delete
    public void deleteActivity(Activity activity) {
        efl.deleteActivity(activity);
    }

    public void deleteAlert(Alert alert) {
        efl.deleteAlert(alert);
    }

    public void deleteColorimetry(Colorimetry colorimetry) {
        efl.deleteColorimetry(colorimetry);
    }

    public void deleteColorimetrySettings(ColorimetrySettings colorimetrySettings) {
        efl.deleteColorimetrySettings(colorimetrySettings);
    }

    public void deleteComparation(Comparation comparation) {
        efl.deleteComparation(comparation);
    }

    public void deleteFormula(Formula formula) {
        efl.deleteFormula(formula);
    }

    public void deleteFramework(Framework framework) {
        efl.deleteFramework(framework);
    }

    public void deleteGraph(Graph graph) {
        efl.deleteGraph(graph);
    }

    public void deleteIcon(Icon icon) {
        efl.deleteIcon(icon);
    }

    public void deleteLang(Lang lang) {
        efl.deleteLang(lang);
    }

    public void deleteLicense(License license) {
        efl.deleteLicense(license);
    }

    public void deleteMapDrawing(MapDrawing mapDrawing) {
        efl.deleteMapDrawing(mapDrawing);
    }

    public void deleteMapDrawingSettings(MapDrawingSettings mapDrawingSettings) {
        efl.deleteMapDrawingSettings(mapDrawingSettings);
    }

    public void deleteNoteType(NoteType noteType) {
        efl.deleteNoteType(noteType);
    }

    public void deleteProfile(Profile profile) {
        efl.deleteProfile(profile);
    }

    public void deleteSMTP(SMTP SMTP) {
        efl.deleteSMTP(SMTP);
    }

    public void deleteTimePeriod(TimePeriod timePeriod) {
        efl.deleteTimePeriod(timePeriod);
    }

    public void deleteUnit(Unit unit) {
        efl.deleteUnit(unit);
    }
}
